Postprocessing and Output

struct diverge_postprocess_conf_t

Default values are obtained using diverge_postprocess_conf_defaults_CPP() from C/C++/Python and the static constant variable diverge_postprocess_conf_defaults from C.

Note

This documentation does not include the defaults directly, but they are given in the (linked) source file src/diverge_post.h.

Note

Member variables with prefix are used as follows

patch_

used with the patch backend

grid_

used with the grid backend

tu_

used with the tu backend

Note

TUFRG channels are diagonalized in transposed form (cf. diverge_postprocess_conf_t.tu_which_solver_mode)

bool patch_q_matrices

include the channelized matrices in the save

bool patch_q_matrices_use_dV

use dV instead of V for the channelized matrices

int patch_q_matrices_nv

how many eigenvectors. -1: full (no eigen), 0: all, >0: number

double patch_q_matrices_max_rel

restrict analysis to q_norm <= <val>. if <0 or >1, no restriction.

char patch_q_matrices_eigen_which

sort q matrices eigenvalues by ‘M’agnitude, ‘P’ositive, ‘N’egative, or ‘A’lternating values

bool patch_V

include vertex in save

bool patch_dV

include dV in save

bool patch_Lp

include plus loop in save

bool patch_Lm

include minus loop in save

char grid_lingap_vertex_file_P[MAX_NAME_LENGTH]

output the q=0 linearized gap vertex of the P channel to the file (if != “”)

char grid_lingap_vertex_file_C[MAX_NAME_LENGTH]

output the q=0 linearized gap vertex of the C channel to the file (if != “”)

char grid_lingap_vertex_file_D[MAX_NAME_LENGTH]

output the q=0 linearized gap vertex of the D channel to the file (if != “”)

char grid_lingap_vertex_loop_file_P[MAX_NAME_LENGTH]

output the q=0 linearized gap and loop vertex of the P channel to the file (if != “”)

char grid_lingap_vertex_loop_file_C[MAX_NAME_LENGTH]

output the q=0 linearized gap and loop vertex of the C channel to the file (if != “”)

char grid_lingap_vertex_loop_file_D[MAX_NAME_LENGTH]

output the q=0 linearized gap and loop vertex of the D channel to the file (if != “”)

int grid_n_singular_values

number of singular values to save for the lineraized gap solutions

bool grid_use_loop

include the loop in the linearized gap solution

char grid_vertex_file[MAX_NAME_LENGTH]

write the full vertex to this file (if != “”)

char grid_vertex_chan

choose the channel to write the vertex in

char tu_which_solver_mode

choose how to handle non hermitian entries of the channel diagonalization. options: ‘a’(utomatic), ‘s’(vd), ‘e’(igen), ‘b’(atched eigen), ‘B’(atched SVD). For ‘a’(utomatic), one can use tu_which_solver_mode_hermiticity_limit to set a “zero” value for hermiticity detection.

Note

The diagonalization happens in Channel-native memory order (e.g. (q,43,21) for the P Channel written in C ordering). As a consequence, the eigenvectors are (21) rather than (34) what you might expect. Effectively this means you get the eigenvectors of the transposed channel, not the true channel. For chiral systems, this makes a difference…

bool tu_skip_channel_calc

if true, the eigenvectors of each channel are not calculated. useful for RPA calculations

double tu_storing_threshold

sets a theshold above which all eigen/singular vectors will be stored (magnitude). If the return value of the function diverge_postprocess_conf_tu_storing_threshold_qrelative() (an IEEE 754 Quiet NaN with a suitable payload) is used, the relative storing threshold (which is the input to the function diverge_postprocess_conf_tu_storing_threshold_qrelative()) is taken over all q points of the channels, which can be very useful if a lot of data points are taken for, e.g., a phase diagram scan.

bool tu_storing_relative

use a relative storing threshold instead of the aboslute one

index_t tu_n_singular_values

number of singular/eigen values to save for the lineraized gap solutions

bool tu_lingap

calculate the linearized gap solution

bool tu_susceptibilities_full

calculate the susceptibilities from tufrg in o_1-o_4 notation

bool tu_susceptibilities_ff

calculate the susceptibilities from tufrg in formfactor space

int tu_selfenergy

store the selfenergy if it was included in the calculation. Iff < 0, transform the selfenergy to real space hopping parameters using diverge_model_ham2hop_fg() (see tu_selfenergy_rs_dist and tu_selfenergy_rs_mval).

int tu_channels

store the vertices in the formfactor basis (requires a lot of memory). if <0 project the full vertex to a channel and then save.

bool tu_symmetry_maps

store the symmetry transfromations for the left multiindex (works for eigenvectors)

index_t tu_n_decomp_values

store the N leading values of the channel eigendecomposition/SVD. ignored if zero

bool tu_lingap_atscale

use the at-scale propagator instead of the integrated one in the linearized gap, useful for RPA

char tu_lingap_solver_mode[4]

choose how to handle diagonalizations in the linearized gap equations for each of the channels (PCD, as index), useful for RPA. options: 's' (svd), 'E' (eigen, sort by absolute value), 'e' (eigen, sort alternating), 't' (eigen, sort from largest), 'b' (eigen, sort from smallest)

int tu_susceptibilities_bare

output the (flowing) bare susceptibilities, i.e., the integrated loop derivative. May result in large files. Iff < 0, reconstruct the full ones instead of outputting reduced ones (iff > 0).

int tu_channel_calc_project

project the full vertex into the respective diagrammatic channel (if > 0) for diagonalization, or to physical channels (if < 0). Note that this flag has an effect only when tu_skip_channel_calc is false.

double tu_which_solver_mode_hermiticity_limit

limit up to which to consider a matrix “hermitian” when the solver mode in tu_which_solver_mode is ‘a’. limit is applied to the maximum entry of the difference of the matrix and its hermitian conjugate.

char tu_rpa_chans[6]

select channels for vertices that are projected to the P channel at q=0 and then considered for diagonalization in linearized gap of RPA attachment. must be particle-hole channels; naming follows diverge_flow_step_vertex().

char tu_rpa_include_chi_pp

include the particle-particle bubble calculated explicitly in k space

char tu_rpa_include_V_pp

include the pairing vertex in kk’ space

int tu_rpa_nev

number of eigenvalues to calculate in RPA attachment. Unless -DUSE_ARPACK_EIGENSOLVER is used at compile time (and the library is linked to arpack) the postprocessing falls back to a lapack eigensolver that goes for all eigenvalues; and is very slow.

int tu_rpa_ncv

size of Krylov space for eigensolver in RPA attachment (only enabled when library is compiled with -DUSE_ARPACK_EIGENSOLVER)

int tu_rpa_maxiter

number of Kryolv iterations for eigensolver in RPA attachment (only enabled when library is compiled with -DUSE_ARPACK_EIGENSOLVER)

double tu_rpa_tol

tolerance of eigensolver in RPA attachment (only enabled when library is compiled with -DUSE_ARPACK_EIGENSOLVER)

char tu_rpa_sorting

eigenvalue sorting and selection: most ‘N’egative, most ‘P’ositive, or largest ‘M’agnitude (cf. single_eigen_sort())

float tu_selfenergy_rs_dist

maximal distance for (real space) selfenergy storage; in units of first lattice vector.

float tu_selfenergy_rs_mval

minimal value for (real space) selfenergy storage; in units of energy.

static const diverge_postprocess_conf_t diverge_postprocess_conf_defaults

defaults for C

diverge_postprocess_conf_t diverge_postprocess_conf_defaults_CPP(void)

return default values in C, C++, and Python

double diverge_postprocess_conf_tu_storing_threshold_qrelative(double threshold)

return a IEEE 754 Quiet NaN with the payload threshold to use as parameter in diverge_postprocess_conf_t.tu_storing_threshold and force relative operation across all q points of each channel. Essentially a wrapper around diverge_fnan_gen() (or fnan_gen()).

void diverge_postprocess_and_write(diverge_flow_step_t *st, const char *file)

Post-processing and output to disk as .dvg file. Those files can be read by the diverge.output Python library (see Simulation Output). File format specification depends on the chosen backend. In general, the header (shown in the figures) is followed by data. For the TUFRG backend, displacements are in bytes while sizes are in units of the respective datatype. For the other backends, all units are index_t (i.e. 64bit). Default values from diverge_postprocess_conf_t (i.e. diverge_postprocess_conf_defaults_CPP()) are taken. For more control, use diverge_postprocess_and_write_finegrained() or its pyhton wrapper diverge.postprocess_and_write_PY().

Hint

if -DUSE_COMPRESSED_OUTPUT is enabled at compile time, the postprocessing output file and all ancillary files will be zstd compressed. The Simulation Output library handles this automatically via zstd’s magic number for .dvg files, binaries have to be checked manually!

Grid-FRG:

Patch-FRG:

TUFRG:

as for model output files (see diverge_model_to_file()), the TUFRG output file has reserved space for the future. If the 125th field is nonzero, the actual header size is 256*sizeof(int64_t).

void diverge_postprocess_and_write_finegrained(diverge_flow_step_t *st, const char *file, const diverge_postprocess_conf_t *cfg)

same as diverge_postprocess_and_write() but with control over the parameters in diverge_postprocess_conf_t. diverge_postprocess_and_write() uses the defaults (diverge_postprocess_conf_defaults or diverge_postprocess_conf_defaults_CPP()).

void diverge_postprocess_and_write_fg(diverge_flow_step_t *st, const char *file, const diverge_postprocess_conf_t *cfg)

alias for diverge_postprocess_and_write_finegrained()